package dao;

import org.hibernate.HibernateException;
import org.hibernate.MappingException;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;

public class Hibernate {

    private static Configuration configuration = null;
    private static SessionFactory sessionFactory = null;
    private static Session session = null;
    private static Transaction tx = null;
    public static int cantidadGuardada = 0;
    public static int cantidadNoGuardada = 0;

    /**
     * Método que devuelve la configuración del objeto Documento
     *
     * @return Configutarion clase con la configuración de las clases.
     */
    public static Configuration getConfiguration() {

        if (configuration == null) {
            configuration = new Configuration();
            try {
                configuration.addClass(negocio.Documento.class);
                configuration.addClass(negocio.Usuario.class);
                configuration.addClass(negocio.Vocabulario.class);
                configuration.addClass(negocio.Posteo.class);
                configuration.addClass(negocio.Feed.class);
            } catch (MappingException e) {
                System.console().writer().print(e);
            }
        }
        return configuration;
    }

    /**
     * Método que obtiene la fabrica de sesión de Hibernate
     *
     * @return SessionFactory 
     */
    public static SessionFactory getSessionFactory() {
        if (sessionFactory == null) {
            try {
                sessionFactory = getConfiguration().buildSessionFactory();
            } catch (HibernateException e) {
                String toString = e.toString();
                throw e;
            }
        }
        return sessionFactory;
    }

    /**
     * Método que devuelve el objeto Session de Hibernate.
     * 
     * @return Session el objeto sesión actual.
     */
    public static Session getSession() {
        if (session == null || !session.isOpen()) {
            try {
                session = getSessionFactory().openSession();
            } catch (HibernateException e) {
                System.out.println(e);
            }
        }
        return session;
    }

    /**
     * Método para guardar un objeto a través de Hibernate.
     * 
     * @param c Un objeto que se quiera persistir.
     */
    public static void guardarObjeto(Object c) {
        try {
            tx = getSession().beginTransaction();
            session.save(c);
            cantidadGuardada++;
            tx.commit();
            session.close();
        } catch (HibernateException e) {
            cantidadNoGuardada++;
            session.close();
            System.out.println("ERROR AL GUARDAR OBJETO " + e);
            e.printStackTrace();
        }
    }

    /**
     * Método para actualizar un objeto.
     *
     * @param object El objeto que se quiere actualizar.
     */
    public static void updateObjeto(Object object) {
        try {
            tx = getSession().beginTransaction();
            session.update(object);
            tx.commit();
            session.close();
        } catch (HibernateException e) {
            session.close();
            System.out.println("ERROR AL ACTUALIZAR OBJETO " + e);
        }
    }

    /**
     * Método que actualiza o guarda un objeto.
     * 
     * @param object El objeto que se quiere actualizar o grabar.
     */
    public static void saveOrUpdateObjeto(Object object) {
        try {
            tx = getSession().beginTransaction();
            session.saveOrUpdate(object);
            tx.commit();
            session.close();
        } catch (HibernateException e) {
            session.close();
            System.out.println("ERROR AL GUARDAR O ACTUALIZAR OBJETO " + e);
        }
    }
}
